Challenges in Distributed Real-Time Systems: Scheduling and Synchronization

REACTION 2012. 1st International workshop on Real-time and distributed computing in emerging applications. December 4th, 2012, San Juan, Puerto Rico

Extracting parallelism at compile-time through dependence analysis & cloning techniques in an object-based paradigm

The construct of Abstract Data Type (ADT) modules and Abstract Data Object (ADO) modules supported by most object-based languages are a great source for developing reusable code. To improve the run time performance of such object-based programs, we consider the asynchronous remote procedure call (ARPC) model of parallel execution, in which concurrency is achieved by having the caller and the callee (which are module instances) running on different processors. Frequently, an ADT module is needed simultaneously by other modules, thus causing contention. To resolve this, we clone the module instance in demand and distribute the copies across different processors, so that multiple clients can access the code concurrently. For identifying the facilities causing bottlenecks to the ARPC model, the dependence relations of the code is analyzed at compile-time. Instance dependences of the code are also analyzed in addition to conventional dependences to reveal the potential concurrency, and an upper bound on the number of clones of each facility that could be used in an application is determined. This parallelism information could be used by the assignment and the scheduling algorithms in the run time environment of the application for constructing a feasible real-time schedule, statically

Managing Soft-errors in Transactional Systems

Abstract-Multicore architectures are becoming increasingly prone to soft-errors -i.e., transient faults caused by external physical phenomena such as electric noise and cosmic particle strikes. With increasing core counts, the soft-error rate is growing due to the accelerating transistor density on chips. The impact of these errors on business-critical applications that are being deployed on multicore hardware can be significant. We present an active replication-based approach that fully masks such errors for transactional applications. We partition computational cores, fully replicate objects across partitions, and concurrently execute transactional requests on all partitions, thereby enabling completely local object accesses. Transactional requests are globally ordered and delivered across partitions using optimistic atomic broadcast. Hardware message passing -an important emerging trend in multicore architectures -is exploited to mitigate communication costs. We report preliminary results obtained with an implementation of our approach on a 36-core Tilera TILE-Gx hardware, with an onchip scalable mesh network